home *** CD-ROM | disk | FTP | other *** search
/ Cre@te Online 2000 December / Cre@teOnline CD05.iso / MacSoft / XML ConsoleMax.sea / XML ConsoleMax / Required / ldapjdk.jar / LDAPSearch.class (.txt) < prev    next >
Encoding:
Java Class File  |  1999-04-13  |  11.2 KB  |  551 lines
  1. import java.io.File;
  2. import java.io.FileOutputStream;
  3. import java.io.IOException;
  4. import java.io.PrintWriter;
  5. import java.util.Enumeration;
  6. import java.util.Locale;
  7. import java.util.StringTokenizer;
  8. import java.util.Vector;
  9. import netscape.ldap.LDAPAttribute;
  10. import netscape.ldap.LDAPAttributeSet;
  11. import netscape.ldap.LDAPCompareAttrNames;
  12. import netscape.ldap.LDAPConnection;
  13. import netscape.ldap.LDAPControl;
  14. import netscape.ldap.LDAPException;
  15. import netscape.ldap.LDAPReferralException;
  16. import netscape.ldap.LDAPSearchConstraints;
  17. import netscape.ldap.LDAPSearchResults;
  18. import netscape.ldap.LDAPSortKey;
  19. import netscape.ldap.LDAPUrl;
  20. import netscape.ldap.controls.LDAPSortControl;
  21. import netscape.ldap.controls.LDAPVirtualListControl;
  22. import netscape.ldap.controls.LDAPVirtualListResponse;
  23. import netscape.ldap.util.ByteBuf;
  24. import netscape.ldap.util.GetOpt;
  25. import netscape.ldap.util.LDIF;
  26. import netscape.ldap.util.MimeBase64Encoder;
  27.  
  28. public class LDAPSearch extends LDAPTool {
  29.    private static boolean m_attrsonly;
  30.    private static int m_deref;
  31.    private static int m_scope = 2;
  32.    private static int m_sizelimit;
  33.    private static int m_timelimit;
  34.    private static int verbose;
  35.    private static String[] m_attrs = null;
  36.    private static String m_base = "o=ace industry,c=us";
  37.    private static String m_filter = null;
  38.    private static String m_sep = ":";
  39.    private static Vector m_sort = new Vector();
  40.    private static boolean m_sortOnServer;
  41.    private static boolean m_tempFiles;
  42.    private static int m_beforeCount;
  43.    private static int m_afterCount;
  44.    private static int m_index;
  45.    private static int m_count;
  46.    private static int m_vlvTokens;
  47.    private static String m_searchVal = null;
  48.    private static boolean m_foldLine = true;
  49.    private static final int MAX_LINE = 77;
  50.    private static PrintWriter m_pw;
  51.  
  52.    public static void main(String[] var0) {
  53.       extractParameters(var0);
  54.       if (!LDAPTool.m_justShow) {
  55.          try {
  56.             LDAPTool.m_client = new LDAPConnection();
  57.             LDAPTool.m_client.connect(LDAPTool.m_ldaphost, LDAPTool.m_ldapport);
  58.          } catch (Exception var4) {
  59.             System.err.println("Error: client connection failed!");
  60.             System.exit(0);
  61.          }
  62.  
  63.          try {
  64.             LDAPTool.m_client.authenticate(LDAPTool.m_version, LDAPTool.m_binddn, LDAPTool.m_passwd);
  65.          } catch (Exception var3) {
  66.             System.err.println(((Throwable)var3).toString());
  67.             System.exit(0);
  68.          }
  69.  
  70.          dosearch();
  71.          m_pw.flush();
  72.          m_pw.close();
  73.  
  74.          try {
  75.             LDAPTool.m_client.disconnect();
  76.          } catch (Exception var2) {
  77.             System.err.println(((Throwable)var2).toString());
  78.          }
  79.       }
  80.  
  81.       System.exit(0);
  82.    }
  83.  
  84.    private static void doUsage() {
  85.       System.err.println("usage: LDAPSearch -b basedn [options] filter [attributes...]");
  86.       System.err.println("options");
  87.       System.err.println("  -h host       LDAP server name or IP address");
  88.       System.err.println("  -p port       LDAP server TCP port number");
  89.       System.err.println("  -V version    LDAP protocol version number (default is 3)");
  90.       System.err.println("  -D binddn     bind dn");
  91.       System.err.println("  -w password   bind passwd (for simple authentication)");
  92.       System.err.println("  -v            run in verbose mode");
  93.       System.err.println("  -n            show what would be done but don't actually do it");
  94.       System.err.println("  -d level      set LDAP debugging level to 'level'");
  95.       System.err.println("  -R            do not automatically follow referrals");
  96.       System.err.println("  -O hop limit  maximum number of referral hops to traverse");
  97.       System.err.println("  -H            display usage information");
  98.       System.err.println("  -t            write values to files");
  99.       System.err.println("  -A            retrieve attribute names only");
  100.       System.err.println("  -F sep        print 'sep' instead of '=' between attribute names and values");
  101.       System.err.println("  -S attr       sort the results by attribute 'attr'");
  102.       System.err.println("  -s scope      one of base, one, or sub (search scope)");
  103.       System.err.println("  -a deref      one of never, always, search, or find (alias dereferencing)");
  104.       System.err.println("  -l timelimit  time limit (in seconds) for search");
  105.       System.err.println("  -T            do not fold (wrap) long lines (default is to fold)");
  106.       System.err.println("  -x            perform sorting on server");
  107.       System.err.println("  -M            manage references (treat them as regular entries)");
  108.       System.err.println("  -z sizelimit  size limit (in entries) for search");
  109.       System.err.println("  -G before:after:index:count | before:after:value where 'before' and 'after' are the number of entries surrounding 'index'. 'count' is the content count, 'value' is the search value.");
  110.       System.err.println("  -y proxy-DN   DN to use for access control");
  111.    }
  112.  
  113.    protected static void extractParameters(String[] var0) {
  114.       GetOpt var1 = LDAPTool.extractParameters("HATtxvna:b:F:l:s:S:z:G:", var0);
  115.       if (var1.hasOption('H')) {
  116.          doUsage();
  117.          System.exit(0);
  118.       }
  119.  
  120.       if (var1.hasOption('A')) {
  121.          m_attrsonly = true;
  122.       }
  123.  
  124.       if (var1.hasOption('x')) {
  125.          m_sortOnServer = true;
  126.       }
  127.  
  128.       if (var1.hasOption('t')) {
  129.          m_tempFiles = true;
  130.       }
  131.  
  132.       if (var1.hasOption('F')) {
  133.          m_sep = var1.getOptionParam('F');
  134.       }
  135.  
  136.       if (var1.hasOption('a')) {
  137.          String var2 = var1.getOptionParam('a');
  138.          if (var2.equalsIgnoreCase("never")) {
  139.             m_deref = 0;
  140.          } else if (var2.equalsIgnoreCase("search")) {
  141.             m_deref = 1;
  142.          } else if (var2.equalsIgnoreCase("find")) {
  143.             m_deref = 2;
  144.          } else if (var2.equalsIgnoreCase("always")) {
  145.             m_deref = 3;
  146.          } else {
  147.             System.err.println("Error: alias deref option should be never, search, find, or always.");
  148.          }
  149.       }
  150.  
  151.       if (var1.hasOption('b')) {
  152.          m_base = var1.getOptionParam('b');
  153.       }
  154.  
  155.       if (var1.hasOption('S')) {
  156.          m_sort.addElement(var1.getOptionParam('S'));
  157.       }
  158.  
  159.       if (var1.hasOption('l')) {
  160.          try {
  161.             m_timelimit = Integer.parseInt(var1.getOptionParam('l'));
  162.          } catch (NumberFormatException var7) {
  163.             m_timelimit = 0;
  164.          }
  165.       }
  166.  
  167.       if (var1.hasOption('s')) {
  168.          String var8 = var1.getOptionParam('s');
  169.          if (var8.equalsIgnoreCase("base")) {
  170.             m_scope = 0;
  171.          } else if (var8.equalsIgnoreCase("one")) {
  172.             m_scope = 1;
  173.          } else if (var8.equalsIgnoreCase("sub")) {
  174.             m_scope = 2;
  175.          } else {
  176.             System.err.println("Error: scope should be base, one or sub.");
  177.          }
  178.       }
  179.  
  180.       if (var1.hasOption('z')) {
  181.          try {
  182.             m_sizelimit = Integer.parseInt(var1.getOptionParam('z'));
  183.          } catch (NumberFormatException var6) {
  184.             m_sizelimit = 0;
  185.          }
  186.       }
  187.  
  188.       if (var1.hasOption('T')) {
  189.          m_foldLine = false;
  190.       }
  191.  
  192.       parseVlv(var1);
  193.       Enumeration var9 = var1.getParameters().elements();
  194.       Vector var3 = new Vector();
  195.  
  196.       while(var9.hasMoreElements()) {
  197.          var3.addElement(var9.nextElement());
  198.       }
  199.  
  200.       int var4 = var3.size();
  201.       if (var4 <= 0) {
  202.          System.err.println("Error: must supply filter string!");
  203.          doUsage();
  204.          System.exit(0);
  205.       }
  206.  
  207.       if (var4 == 1) {
  208.          m_filter = (String)var3.elementAt(0);
  209.          if (LDAPTool.m_verbose) {
  210.             System.err.println("filter pattern: " + m_filter);
  211.          }
  212.  
  213.          m_attrs = null;
  214.          if (LDAPTool.m_verbose) {
  215.             System.err.println("returning: ALL");
  216.             System.err.println("filter is: (" + m_filter + ")");
  217.          }
  218.       }
  219.  
  220.       if (var4 > 1) {
  221.          m_filter = (String)var3.elementAt(0);
  222.          if (LDAPTool.m_verbose) {
  223.             System.err.println("filter pattern: " + m_filter);
  224.             System.err.print("returning:");
  225.          }
  226.  
  227.          m_attrs = new String[var4];
  228.  
  229.          for(int var5 = 1; var5 < var4; ++var5) {
  230.             m_attrs[var5 - 1] = (String)var3.elementAt(var5);
  231.             if (LDAPTool.m_verbose) {
  232.                System.err.print(" " + m_attrs[var5 - 1]);
  233.             }
  234.          }
  235.  
  236.          if (LDAPTool.m_verbose) {
  237.             System.err.println();
  238.             System.err.println("filter is: (" + m_filter + ")");
  239.          }
  240.       }
  241.  
  242.    }
  243.  
  244.    private static void parseVlv(GetOpt var0) {
  245.       if (var0.hasOption('G')) {
  246.          String var1 = var0.getOptionParam('G');
  247.          StringTokenizer var2 = new StringTokenizer(var1, ":");
  248.          m_vlvTokens = var2.countTokens();
  249.          if (m_vlvTokens < 3) {
  250.             doUsage();
  251.             System.exit(0);
  252.          }
  253.  
  254.          try {
  255.             m_beforeCount = Integer.parseInt((String)var2.nextElement());
  256.          } catch (NumberFormatException var6) {
  257.             m_beforeCount = 0;
  258.          }
  259.  
  260.          try {
  261.             m_afterCount = Integer.parseInt((String)var2.nextElement());
  262.          } catch (NumberFormatException var5) {
  263.             m_afterCount = 0;
  264.          }
  265.  
  266.          if (m_vlvTokens == 3) {
  267.             m_searchVal = (String)var2.nextElement();
  268.             return;
  269.          }
  270.  
  271.          if (m_vlvTokens > 3) {
  272.             try {
  273.                m_index = Integer.parseInt((String)var2.nextElement());
  274.             } catch (NumberFormatException var4) {
  275.                m_index = 0;
  276.             }
  277.  
  278.             try {
  279.                m_count = Integer.parseInt((String)var2.nextElement());
  280.                return;
  281.             } catch (NumberFormatException var3) {
  282.                m_count = 0;
  283.                return;
  284.             }
  285.          }
  286.       }
  287.  
  288.    }
  289.  
  290.    private static void dosearch() {
  291.       LDAPControl[] var0 = null;
  292.  
  293.       try {
  294.          Vector var1 = new Vector();
  295.          LDAPSortControl var2 = null;
  296.          if (m_sortOnServer && m_sort.size() > 0) {
  297.             LDAPSortKey[] var3 = new LDAPSortKey[m_sort.size()];
  298.  
  299.             for(int var4 = 0; var4 < var3.length; ++var4) {
  300.                var3[var4] = new LDAPSortKey((String)m_sort.elementAt(var4));
  301.             }
  302.  
  303.             var2 = new LDAPSortControl(var3, true);
  304.             var1.addElement(var2);
  305.          }
  306.  
  307.          if (var2 == null && m_vlvTokens >= 3) {
  308.             System.err.println("Server-side sorting is required for virtual list option");
  309.             doUsage();
  310.             System.exit(0);
  311.          }
  312.  
  313.          LDAPVirtualListControl var10 = null;
  314.          if (m_vlvTokens == 3) {
  315.             var10 = new LDAPVirtualListControl(m_searchVal, m_beforeCount, m_afterCount);
  316.          } else if (m_vlvTokens > 3) {
  317.             var10 = new LDAPVirtualListControl(m_index, m_beforeCount, m_afterCount, m_count);
  318.          }
  319.  
  320.          if (var10 != null) {
  321.             var1.addElement(var10);
  322.          }
  323.  
  324.          if (LDAPTool.m_proxyControl != null) {
  325.             var1.addElement(LDAPTool.m_proxyControl);
  326.          }
  327.  
  328.          if (LDAPTool.m_ordinary) {
  329.             LDAPControl var12 = new LDAPControl("2.16.840.1.113730.3.4.2", true, (byte[])null);
  330.             var1.addElement(var12);
  331.          }
  332.  
  333.          if (var1.size() > 0) {
  334.             var0 = new LDAPControl[var1.size()];
  335.             var1.copyInto(var0);
  336.          }
  337.       } catch (Exception var6) {
  338.          System.err.println(((Throwable)var6).toString());
  339.          System.exit(0);
  340.       }
  341.  
  342.       LDAPSearchResults var7 = null;
  343.  
  344.       try {
  345.          LDAPSearchConstraints var8 = (LDAPSearchConstraints)LDAPTool.m_client.getSearchConstraints().clone();
  346.          var8.setServerControls(var0);
  347.          var8.setDereference(m_deref);
  348.          var8.setMaxResults(m_sizelimit);
  349.          var8.setTimeLimit(m_timelimit);
  350.          var8.setReferrals(LDAPTool.m_referrals);
  351.          if (LDAPTool.m_referrals) {
  352.             LDAPTool.setDefaultReferralCredentials(var8);
  353.          }
  354.  
  355.          var8.setHopLimit(LDAPTool.m_hopLimit);
  356.          var7 = LDAPTool.m_client.search(m_base, m_scope, m_filter, m_attrs, m_attrsonly, var8);
  357.       } catch (Exception var5) {
  358.          System.err.println(((Throwable)var5).toString());
  359.          System.exit(1);
  360.       }
  361.  
  362.       if (m_sort.size() > 0 && !m_sortOnServer) {
  363.          String[] var9 = new String[m_sort.size()];
  364.  
  365.          for(int var11 = 0; var11 < var9.length; ++var11) {
  366.             var9[var11] = (String)m_sort.elementAt(var11);
  367.          }
  368.  
  369.          var7.sort(new LDAPCompareAttrNames(var9));
  370.       }
  371.  
  372.       printResults(var7);
  373.       showControls(LDAPTool.m_client.getResponseControls());
  374.    }
  375.  
  376.    private static void printResults(LDAPSearchResults var0) {
  377.       try {
  378.          while(var0.hasMoreElements()) {
  379.             Object var1 = null;
  380.  
  381.             try {
  382.                var18 = var0.next();
  383.             } catch (LDAPReferralException var16) {
  384.                LDAPUrl[] var3 = var16.getURLs();
  385.                System.err.println("Referral entries: ");
  386.  
  387.                for(int var4 = 0; var4 < var3.length; ++var4) {
  388.                   System.err.println("\t" + var3[var4].getUrl().toString());
  389.                }
  390.                continue;
  391.             }
  392.  
  393.             String var2 = var18.getDN();
  394.             if (var2 != null) {
  395.                String var19 = "dn" + m_sep + " " + var2;
  396.                if (m_foldLine) {
  397.                   LDIF.breakString(m_pw, var19, 77);
  398.                } else {
  399.                   m_pw.print(var19);
  400.                   m_pw.print('\n');
  401.                }
  402.             } else {
  403.                String var20 = "dn" + m_sep;
  404.                if (m_foldLine) {
  405.                   LDIF.breakString(m_pw, var20, 77);
  406.                } else {
  407.                   m_pw.print(var20);
  408.                   m_pw.print('\n');
  409.                }
  410.             }
  411.  
  412.             LDAPAttributeSet var21 = var18.getAttributeSet();
  413.             Enumeration var22 = var21.getAttributes();
  414.  
  415.             while(var22.hasMoreElements()) {
  416.                LDAPAttribute var5 = (LDAPAttribute)var22.nextElement();
  417.                String var6 = var5.getName();
  418.                if (m_attrsonly) {
  419.                   String var23 = var6 + ":";
  420.                   if (m_foldLine) {
  421.                      LDIF.breakString(m_pw, var23, 77);
  422.                   } else {
  423.                      m_pw.print(var23);
  424.                      m_pw.print('\n');
  425.                   }
  426.                } else {
  427.                   Enumeration var7 = var5.getByteValues();
  428.                   if (var7 != null) {
  429.                      while(var7.hasMoreElements()) {
  430.                         if (m_tempFiles) {
  431.                            try {
  432.                               FileOutputStream var8 = getTempFile(var6);
  433.                               var8.write((byte[])var7.nextElement());
  434.                            } catch (Exception var15) {
  435.                               System.err.println("Error writing values of " + var6 + ", " + ((Throwable)var15).toString());
  436.                               System.exit(1);
  437.                            }
  438.                         } else {
  439.                            byte[] var24 = (byte[])var7.nextElement();
  440.                            Object var9 = null;
  441.                            if (LDIF.isPrintable(var24)) {
  442.                               String var25 = new String(var24, "UTF8");
  443.                               String var10 = var6 + m_sep + " " + var25;
  444.                               if (m_foldLine) {
  445.                                  LDIF.breakString(m_pw, var10, 77);
  446.                               } else {
  447.                                  m_pw.print(var10);
  448.                                  m_pw.print('\n');
  449.                               }
  450.                            } else {
  451.                               ByteBuf var27 = new ByteBuf(var24, 0, var24.length);
  452.                               ByteBuf var11 = new ByteBuf();
  453.                               MimeBase64Encoder var12 = new MimeBase64Encoder();
  454.                               var12.translate(var27, var11);
  455.                               int var13 = var11.length();
  456.                               if (var13 > 0) {
  457.                                  String var26 = new String(var11.toBytes(), 0, var13);
  458.                                  String var14 = var6 + ":: " + var26;
  459.                                  if (m_foldLine) {
  460.                                     LDIF.breakString(m_pw, var14, 77);
  461.                                  } else {
  462.                                     m_pw.print(var14);
  463.                                     m_pw.print('\n');
  464.                                  }
  465.                               } else {
  466.                                  m_pw.print(var6 + ": \n");
  467.                               }
  468.                            }
  469.                         }
  470.                      }
  471.                   } else {
  472.                      System.err.println("Failed to do string conversion for " + var6);
  473.                   }
  474.                }
  475.             }
  476.  
  477.             m_pw.println();
  478.          }
  479.  
  480.       } catch (Exception var17) {
  481.          System.err.println(((Throwable)var17).toString());
  482.          System.exit(0);
  483.       }
  484.    }
  485.  
  486.    private static void printString(String var0) {
  487.       if (m_foldLine) {
  488.          LDIF.breakString(m_pw, var0, 77);
  489.       } else {
  490.          m_pw.print(var0);
  491.          m_pw.print('\n');
  492.       }
  493.    }
  494.  
  495.    private static void showControls(LDAPControl[] var0) {
  496.       if (var0 != null) {
  497.          int[] var1 = new int[1];
  498.          String var2 = LDAPSortControl.parseResponse(var0, var1);
  499.          if (var1[0] != 0) {
  500.             System.err.println("Error code: " + var1[0]);
  501.             if (var2 != null) {
  502.                System.err.println("Offending attribute: " + var2);
  503.             } else {
  504.                System.err.println("No offending attribute returned");
  505.             }
  506.          } else {
  507.             m_pw.println("Server indicated results sorted OK");
  508.          }
  509.  
  510.          LDAPVirtualListResponse var3 = LDAPVirtualListResponse.parseResponse(var0);
  511.          if (var3 != null) {
  512.             int var4 = var3.getResultCode();
  513.             if (var4 == 0) {
  514.                m_pw.println("Server indicated virtual list positioning OK");
  515.                m_pw.println("index " + var3.getFirstPosition() + " content count " + var3.getContentCount());
  516.                return;
  517.             }
  518.  
  519.             System.err.println("Virtual List Error: " + LDAPException.errorCodeToString(var4, Locale.getDefault()));
  520.          }
  521.  
  522.       }
  523.    }
  524.  
  525.    private static FileOutputStream getTempFile(String var0) throws IOException {
  526.       int var1 = 0;
  527.  
  528.       File var2;
  529.       String var3;
  530.       do {
  531.          var3 = var0 + '.' + var1;
  532.          var2 = new File(var3);
  533.          ++var1;
  534.       } while(var2.exists());
  535.  
  536.       String var4 = var0 + m_sep + " " + var3;
  537.       if (m_foldLine) {
  538.          LDIF.breakString(m_pw, var4, 77);
  539.       } else {
  540.          m_pw.print(var4);
  541.          m_pw.print('\n');
  542.       }
  543.  
  544.       return new FileOutputStream(var2);
  545.    }
  546.  
  547.    static {
  548.       m_pw = new PrintWriter(System.out);
  549.    }
  550. }
  551.